package cn.spdb.harrier.server.worker.exec;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import cn.spdb.harrier.dao.entity.UdsJob;
import cn.spdb.harrier.dao.entity.UdsJobStepRecord;
import cn.spdb.harrier.dao.utils.BeanContext;
import cn.spdb.harrier.server.entity.JobExecutionContext;
import cn.spdb.harrier.server.entity.JobStepBean;
import cn.spdb.harrier.server.worker.WorkerManagerThread;
import cn.spdb.harrier.server.worker.task.AbstractTask;

/**
 * <p>{@link ExecuteRunable} 是一个抽象类，用于表示可执行并支持延迟的任务。</p>
 *
 * <p>该类实现了 {@link Runnable} 和 {@link Delayed} 接口，适配于延迟任务调度场景。</p>
 *
 * <p>主要功能包括：
 * - 管理任务上下文（JobExecutionContext）
 * - 构建任务日志记录对象（UdsJobStepRecord）
 * - 支持任务终止操作</p>
 */
public abstract class ExecuteRunable implements Runnable, Delayed {

    /**
     * 从 Spring 容器中获取 WorkerManagerThread 实例，用于任务管理。
     */
    protected static WorkerManagerThread workerManagerThread = BeanContext.getBean(WorkerManagerThread.class);

    /**
     * 标记任务是否被取消执行。
     */
    protected AtomicBoolean cancel = new AtomicBoolean(false);

    /**
     * 日志记录器。
     */
    protected final Logger logger = LoggerFactory.getLogger(TaskExecuteRunnable.class);

    /**
     * 当前任务的执行上下文信息。
     */
    protected JobExecutionContext jobExecutionContext;

    /**
     * 当前正在执行的任务实例。
     */
    protected volatile AbstractTask nowTask;

    /**
     * 比较两个延迟对象的顺序，用于延迟队列排序。
     *
     * @param o 要比较的对象
     * @return 排序结果，0 表示相等
     */
    @Override
    public int compareTo(Delayed o) {
        return 0;
    }

    /**
     * 获取当前对象的剩余延迟时间。
     *
     * @param unit 时间单位
     * @return 剩余延迟时间，单位由参数指定
     */
    @Override
    public long getDelay(TimeUnit unit) {
        return 0;
    }

    /**
     * 获取当前任务的执行上下文。
     *
     * @return 当前任务的执行上下文对象
     */
    public JobExecutionContext getJobExecutionContext() {
        return jobExecutionContext;
    }

    /**
     * 设置当前任务的执行上下文。
     *
     * @param jobExecutionContext 新的执行上下文对象
     */
    public void setJobExecutionContext(JobExecutionContext jobExecutionContext) {
        this.jobExecutionContext = jobExecutionContext;
    }

    /**
     * 构建任务步骤记录对象 UdsJobStepRecord。
     *
     * @param jobId 任务记录 ID
     * @param udsjob 任务实体对象
     * @param stepBean 步骤配置对象
     * @return 构建好的任务步骤记录对象
     */
    public UdsJobStepRecord buildUdsJobStepRecord(Long jobId, UdsJob udsjob, JobStepBean stepBean) {
        UdsJobStepRecord jobStepRecord = new UdsJobStepRecord();
        jobStepRecord.setJobRecordId(jobId);
        jobStepRecord.setPlatform(udsjob.getPlatform());
        jobStepRecord.setSystems(udsjob.getSystems());
        jobStepRecord.setJob(udsjob.getJob());
        jobStepRecord.setNumTimes(udsjob.getNumTimes());
        jobStepRecord.setStepNum(stepBean.getStepNum());
        jobStepRecord.setStartTime(stepBean.getStartTime());
        jobStepRecord.setEnvironments(stepBean.getEnvs());
        jobStepRecord.setCmd(stepBean.getCmd());
        jobStepRecord.setScriptPath(stepBean.getStepPath());
        jobStepRecord.setParameter(stepBean.getPararmeter());
        jobStepRecord.setLogPath(stepBean.getLogPath());
        return jobStepRecord;
    }

    /**
     * 终止当前任务的执行。
     *
     * <p>设置取消标志，并尝试调用底层任务的 kill 方法进行强制终止。</p>
     */
    public void kill() {
        cancel.set(true);
        if (nowTask != null) {
            try {
                nowTask.kill();
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
        }
    }
}
